package Review.Array;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        //数组
        int[] vec=new int[n];
        int pres=0;
        //前i个数组的和
        int[] p=new int[n];
        for(int i=0;i<n;i++){
            vec[i]=sc.nextInt();
            pres+=vec[i];
            p[i]=pres;
        }
        while(sc.hasNext()){
            int a=sc.nextInt();
            int b=sc.nextInt();
            int sum=0;
            if(a==0){
                sum=p[b];
            }
            else{
                //a-1索引下不包含要加入的数据，-1是为加上a索引下的数据
                sum=p[b]-p[a-1];
            }
        }

    }
    //左闭右闭的情况
    public int search(int[] nums,int target){
        //避免造成多次循环
        if(target<nums[0]&&target>nums[nums.length-1]){
            return -1;
        }
        int left=0,right=nums.length-1;
        while(left<right){
            int mid=left+((right-left)>>2);
            if(nums[mid]==target){
                return mid;
            }
            else if(nums[mid]<target){
                left=mid+1;
            }
            else {
                right=mid-1;
            }
        }
        //循环后没有找到
        return -1;
    }

   //移除目标元素,暴力法
    public int removeElement(int[] nums,int target){
        int n=nums.length;
        for(int i=0;i<n;i++){
            if(nums[i]==target){
                for(int j=i+1;i<n;j++){
                    nums[j-1]=nums[j];
                }
                //删除元素后，数组数量减少
                i--;
                n--;
            }
        }
        return n;
    }
    //移除元素，快慢指针法
    public int removeElement2(int[] nums,int target){
        int slowIndex=0;
        for(int fastIndex=0;fastIndex<nums.length;fastIndex++){
            //快慢指针一起移动
            if(nums[fastIndex]!=target){
                //赋值！！
                nums[slowIndex]=nums[fastIndex];
                //慢指针移动
                slowIndex++;
            }
        }
        return slowIndex;
    }
    //有序数组的平方,暴力版
    public int[] sortedSqures(int[] nums){
        for(int i=0;i<nums.length;i++){
            nums[i]=nums[i]*nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
    //有序数组的平方,可能存在负值，所以应该从最左右侧开始
    public int[] sortedSqures2(int[] nums){
        int right=nums.length-1;
        int left=0;
        int[] result=new int[nums.length];
        //最大索引处
        int index=result.length-1;
        while(left<right){
            if(nums[left]*nums[left]>nums[right]*nums[right]){
                result[index--]=nums[left]*nums[left];
                left++;
            }
            else{
                result[index--]=nums[right]*nums[right];
                right++;
            }
        }
        return result;
    }
    //滑动窗口
    public  int midSubArray(int[] nums,int s){
        int left=0;
        int sum=0;
        int result=Integer.MAX_VALUE;
        for(int right=0;right<nums.length;right++){
            sum+=nums[right];
            while(sum>=s){
                //数组索引的特性
                result=Math.min(result,left-right+1);
                //减去相应的值，left向右移动
                sum-=nums[left++];
            }
        }
        //如果不存在就值为零
        return result==Integer.MAX_VALUE?0:result;
    }



}

